home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 1 / PC Actual CD 01.iso / f1 / cimb.arj / MENU.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-03  |  27.8 KB  |  1,243 lines
  1. /*==============================================================================
  2.  
  3. FICHERO: MENU.C
  4.  
  5. AUTOR: ANTONIO LADESA JURADO
  6.  
  7. FECHA: 24/6/94
  8.  
  9. DESCRIPCION:
  10.  
  11.     Fichero que contiene las estructuras, constantes, variables y funciones
  12.     internas y externas para el control y visualización de los menus.
  13.  
  14. ==============================================================================*/
  15.  
  16.  
  17. /*---- MODULOS USADOS --------------------------------------------------------*/
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <graphics.h>
  22. #include <ctype.h>
  23. #include <alloc.h>
  24. #include <string.h>
  25. #include <dir.h>
  26. #include <dos.h>
  27. #include <bios.h>
  28. #include <errno.h>
  29. #include <conio.h>
  30.  
  31. #include "global.h"
  32. #include "raton.h"
  33. #include "error.h"
  34. #include "memoria.h"
  35. #include "teclas.h"
  36. #include "menu.h"
  37.  
  38. /*---- ESTRUCTURAS, CONSTANTES Y VARIABLES LOCALES AL MODULO -----------------*/
  39.  
  40.     /* tabla de formatos, usada tambien para asignar extensiones */
  41. char *tabla_formatos[]=
  42.     {".MAC",".PCX",".GIF",".TIFF",".IMG",".TGA",".BMP"};
  43.  
  44.     /* estructura de lista de ficheros */
  45. struct lista
  46.     {
  47.     char f[13];
  48.     char e;
  49.     struct lista *s;
  50.     struct lista *a;
  51.     };
  52.  
  53.     /* lista de ficheros y directorios */
  54. struct lista *l=NULL,*actual=NULL;
  55.  
  56.     /* cadenas para el manejo de ficheros */
  57. char drive[MAXDIR];
  58. char dir[MAXDIR];
  59. char file[MAXFILE];
  60. char ext[MAXEXT];
  61. struct ffblk ff;
  62.  
  63.     /* estructuras externas usadas */
  64. extern struct TECLA m[NUM_MARCOS];
  65. extern struct TECLA t[NUM_TECLAS];
  66. extern struct EVENTO evento;
  67. extern struct ACCION accion;
  68.  
  69. /*---- DEFINICION DE LAS FUNCIONES INTERNAS ----------------------------------*/
  70.  
  71. int TipoFichero(char *fichero);
  72. struct lista *DirectorioLiberarLista(struct lista *l);
  73. struct lista *DirectorioInsLista(struct lista *l,char *f);
  74. void DirectorioVerLista(struct lista *l);
  75. void DirectorioLeer(char *direc);
  76. void DirectorioTratarLista(int y);
  77. void MENUquitar(int i);
  78.  
  79. /*---- CODIFICACION DE LAS FUNCIONES OFRECIDAS -------------------------------*/
  80.  
  81. /*---- FUNCION: extern int MENUopcion(struct ACCION *accion) -------------------
  82.  
  83.     Descripción:
  84.  
  85.         Esta función es la encargada de leer los eventos producidos y gestionar
  86.         las acciones que estos eventos suponen.
  87.  
  88.     Parámetros:
  89.  
  90.         struct ACCION *accion : accion a realizar segun el evento
  91.  
  92.     Retorno:
  93.  
  94.         Numero de opción si se produce
  95.  
  96.  
  97. ---- CODIGO: -----------------------------------------------------------------*/
  98.  
  99. extern int MENUopcion(struct ACCION *accion)
  100. {
  101.     /* opcion escogida */
  102. int op;
  103.     /* contador auxiliar */
  104. int i;
  105.  
  106.     /* leer evento y traducirlo a opción */
  107. RATONvisible();
  108. evento = leer_evento(evento);
  109. switch(evento.e)
  110.     {
  111.     case RATON_IZDO_ON:
  112.         op = TestTecla(evento.x,evento.y);
  113.     break;
  114.     case BORRAR: op = OPBorrar;break;
  115.     case INSERT: op = OPRenombrar;break;
  116.     case RET: op = OPfichero;break;
  117.     case ESC: op = OPSalir;break;
  118.     default: op = NOOPC;break;
  119.     }
  120. RATONoculto();
  121.  
  122.     /* tratar cada opción */
  123. switch(op)
  124.             {
  125.                 /* si no hay opción, salir */
  126.             case NOOPC:break;
  127.  
  128.                 /* para todas las opciones del menu...*/
  129.             case OPCargar:         case OPVer:                     case OPSalvar:
  130.             case OPNuevo:     case OPReflejoH:          case OPReflejoV:
  131.             case OPByN:       case OPVideoInverso:  case OPGris:
  132.             case OPColores:   case OPImprimir:      case OPVision:
  133.             case OPMemoria:   case OPEscalar:       case OPInformar:
  134.             case OPSalir:
  135.                 /* ...y las relacionadas con los ficheros */
  136.             case OPBorrar:
  137.             case OPRenombrar:
  138.  
  139.                     /* ...resaltar la tecla y devolver la opcion,
  140.                     el programa principal las ejecutará o llamará a otro menu */
  141.                 TECLAresaltar(&t[op]);
  142.                 accion->opcion = op;
  143.             break;
  144.  
  145.                 /* para las unidades de disco...*/
  146.             case OPdriveB:
  147.                     /* si no existe unidad B: */
  148.                 if(!(biosequip() & 0x40))
  149.                     break;
  150.             case OPdriveA:
  151.             case OPdriveC:
  152.                 /* activar la tecla de la unidad correspondiente */
  153.             for(i = OPdriveA;i<=OPdriveC;i++)
  154.                 TECLAdesactivar(&t[i]);
  155.             TECLAactivar(&t[op]);
  156.                 /* preparar la informacion de la nueva unidad de disco */
  157.             fnsplit(accion->fichero,drive,dir,file,ext);
  158.             sprintf(drive,"%c:",op-OPdriveA+'A');
  159.             if(!strcmp(ext,"")) strcpy(ext,".*");
  160.             fnmerge(accion->fichero,drive,"","*",ext);
  161.             accion->tipo = TipoFichero(accion->fichero);
  162.                 /* leer directorio */
  163.             DirectorioLeer(accion->fichero);
  164.             op = NOOPC;
  165.             break;
  166.  
  167.                 /* para todos los formatos... */
  168.             case OPMAC: case OPPCX: case OPGIF: case OPTIF:
  169.             case OPIMG: case OPTGA: case OPBMP:
  170.                     /* activar la tecla y el formato */
  171.                 for(i = OPMAC;i<=OPBMP;i++)
  172.                     TECLAdesactivar(&t[i]);
  173.                 TECLAactivar(&t[op]);
  174.                 fnsplit(accion->fichero,drive,dir,file,ext);
  175.                 strcpy(file,"*");
  176.                 memcpy(ext,tabla_formatos[op-OPMAC],4);
  177.                 fnmerge(accion->fichero,drive,dir,file,ext);
  178.                 accion->tipo = TipoFichero(accion->fichero);
  179.                     /* leer el directorio */
  180.                 DirectorioLeer(accion->fichero);
  181.                 op = NOOPC;
  182.             break;
  183.  
  184.                 /* directorio arriba */
  185.             case OPdirarr:
  186.                     /* resaltar la tecla y desplazar arriba 5 posiciones */
  187.                 TECLAresaltar(&t[op]);
  188.                 for(i=0;i<5;++i)
  189.                     if(actual->a != NULL)
  190.                         actual = actual->a;
  191.                     else
  192.                         break;
  193.                 DirectorioVerLista(actual);
  194.                 op = NOOPC;
  195.             break;
  196.  
  197.                 /* directorio abajo */
  198.             case OPdirabj:
  199.                     /* resaltar la tecla y desplazar abajo 5 posiciones */
  200.                 TECLAresaltar(&t[op]);
  201.                 for(i=0;i<5;++i)
  202.                 if(actual->s != NULL)
  203.                     actual = actual->s;
  204.                 else
  205.                     break;
  206.                 DirectorioVerLista(actual);
  207.                 op = NOOPC;
  208.             break;
  209.  
  210.                 /* seleccionar elemento de la lista */
  211.             case OPlista:
  212.                     /* tratar el elemento seleccionado de la lista */
  213.                 DirectorioTratarLista(evento.y);
  214.                 accion->tipo = TipoFichero(accion->fichero);
  215.                 op = NOOPC;
  216.             break;
  217.  
  218.                 /* editar el nombre del fichero actual */
  219.             case OPfichero:
  220.                 strcpy(accion->fichero,LeerCadena(18,62,224,accion->fichero));
  221.                 accion->tipo = TipoFichero(accion->fichero);
  222.                 DirectorioLeer(accion->fichero);
  223.                 op = NOOPC;
  224.             break;
  225.  
  226.             
  227.     default:op = NOOPC;break;
  228.     }
  229. RATONvisible();
  230. return(op);
  231. }
  232.  
  233. /*---- FIN FUNCION -----------------------------------------------------------*/
  234.  
  235. /*---- FUNCION: extern void MENUponer(void) ------------------------------------
  236.  
  237.     Descripción:
  238.  
  239.         Esta función dibuja el menu principal
  240.  
  241. ---- CODIGO: -----------------------------------------------------------------*/
  242.  
  243. extern void MENUponer(void)
  244. {
  245. unsigned int i;
  246.  
  247.     /* recuadro del menu */
  248. setfillstyle(SOLID_FILL,c3);
  249. cleardevice();
  250. bar(0,0,639,479);
  251.  
  252.     /* poner marcos */
  253. for(i=0;i<3;i++)
  254.     TECLAponer(&m[i]);
  255.  
  256.     /* poner teclas */
  257. for(i=OPCargar;i<=OPBMP;i++)
  258.     TECLAponer(&t[i]);
  259. TECLAponer(&t[OPBorrar]);
  260. TECLAponer(&t[OPRenombrar]);
  261.     /* recuadro ficheros */
  262. TEXTOponer(5,14,"CIMB V. 1.0 Conversor de Imagenes de Mapa de Bits. Antonio Ladesa Jurado.1994");
  263. TEXTOponer(15,49,"Fichero");
  264. TEXTOponer(15,85,"Directorio");
  265. TEXTOponer(175,85,"Unidad");
  266. TEXTOponer(155,204,"Formato");
  267. setcolor(c2);
  268. setfillstyle(SOLID_FILL,c3);
  269. rectangle( 15,59,244,79);
  270. rectangle( 15,95,125,354);
  271. rectangle(125,115,144,334);
  272. rectangle(175,95,234,189);
  273. rectangle(155,214,245,320);
  274. DirectorioLeer(accion.fichero);
  275. }
  276.  
  277. /*---- FIN FUNCION -----------------------------------------------------------*/
  278.  
  279.  
  280. /*---- FUNCION: extern int MENUinicio(void) ------------------------------------
  281.  
  282.     Descripción:
  283.  
  284.         Esta función inicializa el programa, estableciendo ciertos valores
  285.         por defecto
  286.  
  287.     Retorno:
  288.  
  289.         - 1 si inicializa bien
  290.         - 0 si hay error
  291.  
  292. ---- CODIGO: -----------------------------------------------------------------*/
  293.  
  294. extern int MENUinicio(void)
  295. {
  296. int r;
  297.     /* instala el manejador de errores hardware */
  298. ERRORmanejador();
  299.     /* comprueba la existencia del ratón */
  300. r = RATONiniciar();
  301. if(!r || r == -1)
  302.     return(0);
  303.  
  304.     /* selecciona memoria XMS */
  305. MEMSeleccionar(OPXMS);
  306.  
  307.     /* establece directorio actual como directorio activo */
  308. getcwd(accion.fichero,MAXPATH);
  309. if((accion.fichero[strlen(accion.fichero)-1]) != '\\')
  310.     strcat(accion.fichero,"\\");
  311.     /* establece ficheros PCX */
  312. fnsplit(accion.fichero,drive,dir,file,ext);
  313. fnmerge(accion.fichero,drive,dir,"*",".PCX");
  314. accion.tipo = TipoFichero(accion.fichero);
  315. return(1);
  316. }
  317.  
  318. /*---- FIN FUNCION -----------------------------------------------------------*/
  319.  
  320. /*---- FUNCION: extern int MENUimprimirPoner(int *tipo,char *nombre) -----------
  321.  
  322.     Descripción:
  323.  
  324.         Esta función muestra el menu de impresión.
  325.         Devuelve el tipo de impresora y fichero de salida seleccionados
  326.  
  327.     Parámetros:
  328.  
  329.         int *tipo: puntero al tipo de impresora
  330.         char *nombre: puntero al nombre del fichero de salida
  331.  
  332.     Retorno:
  333.  
  334.         - OPImpresion, para imprimir.
  335.         - NOOPC, para no imprimir.
  336.  
  337.  
  338. ---- CODIGO: -----------------------------------------------------------------*/
  339.  
  340. extern int MENUimprimirPoner(int *tipo,char *nombre)
  341. {
  342. int i;
  343. int op;
  344. char fichero[128]="IMPRESORA";
  345.  
  346.     /* poner menu */
  347. RATONoculto();
  348. TECLAponer(&m[3]);
  349. TEXTOponer(270, 50,"Impresion");
  350. rectangle(270, 80,400,155);
  351. TEXTOponer(270, 70,"Impresora");
  352. rectangle(405, 80,535,155);
  353. TEXTOponer(405, 70,"Destino");
  354. TECLAdesactivar(&t[OPdestinoFichero]);
  355. TECLAactivar(&t[OPdestinoImpresora]);
  356. for(i=OPImpresion;i<=OPdestinoImpresora;++i)
  357.     TECLAponer(&t[i]);
  358.  
  359.     /* leer opcion */
  360. do
  361.     {
  362.     RATONvisible();
  363.     evento = leer_evento(evento);
  364.     RATONoculto();
  365.     switch(evento.e)
  366.         {
  367.             /* si es boton izquierdo... */
  368.         case RATON_IZDO_ON:
  369.             op = TestTecla(evento.x,evento.y);
  370.             switch(op)
  371.                 {
  372.                     /* impresora Epson */
  373.                 case OPEpson:
  374.                     TECLAdesactivar(&t[OPPostScript]);
  375.                     TECLAactivar(&t[OPEpson]);
  376.                     *tipo = OPEpson;
  377.                 break;
  378.                     /* impresora PostScript */
  379.                 case OPPostScript:
  380.                     TECLAdesactivar(&t[OPEpson]);
  381.                     TECLAactivar(&t[OPPostScript]);
  382.                     *tipo = OPPostScript;
  383.                 break;
  384.                     /* Impresora */
  385.                 case OPdestinoImpresora:
  386.                     TECLAdesactivar(&t[OPdestinoFichero]);
  387.                     TECLAactivar(&t[OPdestinoImpresora]);
  388.                     strcpy(fichero,"IMPRESORA");
  389.                 break;
  390.                     /* Fichero */
  391.                 case OPdestinoFichero:
  392.                     TECLAdesactivar(&t[OPdestinoImpresora]);
  393.                     TECLAactivar(&t[OPdestinoFichero]);
  394.           strcpy(fichero,nombre);
  395.                     fnsplit(fichero,drive,dir,file,ext);
  396.                     fnmerge(fichero,drive,dir,file,".PRN");
  397.                 break;
  398.                     /* Imprimir */
  399.                 case OPImpresion:
  400.                 break;
  401.                     /* otra, salir */
  402.                 default:
  403.                     op = NOOPC;
  404.                 break;
  405.                 }
  406.         break;
  407.  
  408.             /* otra, salir */
  409.         default:
  410.             op=NOOPC;
  411.         break;
  412.         }
  413.     }
  414. while(op!= NOOPC && op!= OPImpresion);
  415.  
  416. strcpy(nombre,fichero);
  417.     /* quitar menu */
  418. MENUquitar(3);
  419. return(op);
  420. }
  421.  
  422. /*---- FIN FUNCION -----------------------------------------------------------*/
  423.  
  424. /*---- FUNCION: extern int MENUmemoriaPoner(void) ------------------------------
  425.  
  426.     Descripción:
  427.  
  428.         Esta función muestra el menu de memoria
  429.  
  430.     Retorno:
  431.  
  432.         - Tipo de memoria seleccionado
  433.         - NOOPC
  434.  
  435. ---- CODIGO: -----------------------------------------------------------------*/
  436.  
  437. extern int MENUmemoriaPoner(void)
  438. {
  439. int i;
  440. int op;
  441.  
  442.     /* poner menu */
  443. RATONoculto();
  444. TECLAponer(&m[4]);
  445. TEXTOponer(270,180,"Tipo de memoria");
  446. for(i=OPXMS;i<=OPVMS;++i)
  447.     TECLAponer(&t[i]);
  448.  
  449.     /* leer opcion */
  450. RATONvisible();
  451. evento = leer_evento(evento);
  452. RATONoculto();
  453. switch(evento.e)
  454.     {
  455.     case RATON_IZDO_ON:
  456.         op = TestTecla(evento.x,evento.y);
  457.         switch(op)
  458.             {
  459.                 /* si es un tipo de memoria, activarlo */
  460.             case OPXMS:
  461.             case OPEMS:
  462.             case OPVMS:
  463.             for(i = OPXMS;i<=OPVMS;i++)
  464.                 TECLAdesactivar(&t[i]);
  465.             TECLAactivar(&t[op]);
  466.             break;
  467.  
  468.                 /* si no, salir */
  469.             default:
  470.             op = NOOPC;
  471.             break;
  472.             }
  473.         break;
  474.         /* otro, salir */
  475.     default:op=NOOPC;break;
  476.     }
  477. MENUquitar(4);
  478. return(op);
  479. }
  480.  
  481. /*---- FIN FUNCION -----------------------------------------------------------*/
  482.  
  483. /*---- FUNCION: extern int MENUByNPoner(void) ----------------------------------
  484.  
  485.     Descripción:
  486.  
  487.         Esta función muestra el menu de dithering
  488.  
  489.     Retorno:
  490.  
  491.         - Tipo de dithering seleccionado
  492.         - NOOPC
  493.  
  494. ---- CODIGO: -----------------------------------------------------------------*/
  495.  
  496. extern int MENUByNPoner(void)
  497. {
  498. int i;
  499. int op;
  500.  
  501.     /* poner menu */
  502. RATONoculto();
  503. TECLAponer(&m[6]);
  504. TEXTOponer(270,290,"Blanco y Negro");
  505. for(i=OPBayer;i<=OPBurkes;++i)
  506.     TECLAponer(&t[i]);
  507.  
  508.     /* leer opcion */
  509. RATONvisible();
  510. evento = leer_evento(evento);
  511. RATONoculto();
  512. switch(evento.e)
  513.     {
  514.     case RATON_IZDO_ON:
  515.         op = TestTecla(evento.x,evento.y);
  516.         switch(op)
  517.             {
  518.                 /* si es un tipo de dithering, activarlo */
  519.             case OPBayer:
  520.             case OPFloyd:
  521.             case OPStucki:
  522.             case OPBurkes:
  523.             for(i = OPBayer;i<=OPStucki;i++)
  524.                 TECLAdesactivar(&t[i]);
  525.             TECLAactivar(&t[op]);
  526.             break;
  527.  
  528.                 /* si no, salir */
  529.             default:
  530.             op = NOOPC;
  531.             break;
  532.             }
  533.         break;
  534.         /* otro, salir */
  535.     default:op=NOOPC;break;
  536.     }
  537. MENUquitar(6);
  538. return(op);
  539. }
  540.  
  541. /*---- FIN FUNCION -----------------------------------------------------------*/
  542.  
  543. /*---- FUNCION: extern int MENUescalaPoner(int *factorx,int *factory) ----------
  544.  
  545.     Descripción:
  546.  
  547.         Esta función muestra el menu de escalado de imágenes
  548.  
  549.     Parámetros:
  550.  
  551.         int *factorx: factor de escala a lo ancho
  552.         int *factory: factor de escala a lo alto
  553.  
  554.     Retorno:
  555.  
  556.         - OPEscalado, para escalar
  557.         - NOOPC
  558.  
  559. ---- CODIGO: -----------------------------------------------------------------*/
  560.  
  561. extern int MENUescalaPoner(int *factorx,int *factory)
  562. {
  563. char x[4],y[4];
  564. int op,i;
  565.  
  566.     /* poner menu */
  567. RATONoculto();
  568. TECLAponer(&m[5]);
  569. TEXTOponer(270,230,"Factores de escala");
  570. TEXTOponer(350,240,"Factor X:");
  571. TEXTOponer(440,240,"Factor Y:");
  572. for(i=OPanchoMas;i<=OPEscalado;++i)
  573.     TECLAponer(&t[i]);
  574. sprintf(x,"%3d",*factorx);
  575. MENSAJEponer(375,252,30,x);
  576. sprintf(y,"%3d",*factory);
  577. MENSAJEponer(465,252,30,y);
  578.  
  579. do
  580. {
  581.     /* leer opcion */
  582. RATONvisible();
  583. evento = leer_evento(evento);
  584. RATONoculto();
  585.  
  586. switch(evento.e)
  587.     {
  588.     case RATON_IZDO_ON:
  589.         op = TestTecla(evento.x,evento.y);
  590.         switch(op)
  591.             {
  592.                 /* si es escalado, escalar */
  593.             case OPEscalado:
  594.             break;
  595.                 /* si incremento de ancho, incrementar */
  596.             case OPanchoMas:
  597.                 *factorx = (*factorx<200)?*factorx+1:200;
  598.                 sprintf(x,"%3d",*factorx);
  599.                 MENSAJEponer(375,252,30,x);
  600.             break;
  601.                 /* si decremento de ancho, decrementar */
  602.             case OPanchoMenos:
  603.                 *factorx = (*factorx>0)?*factorx-1:0;
  604.                 sprintf(x,"%3d",*factorx);
  605.                 MENSAJEponer(375,252,30,x);
  606.             break;
  607.                 /* si incremento de alto, incrementar */
  608.             case OPaltoMas:
  609.                 *factory = (*factory<200)?*factory+1:200;
  610.                 sprintf(y,"%3d",*factory);
  611.                 MENSAJEponer(465,252,30,y);
  612.             break;
  613.                 /* si decremento de alto, decrementar */
  614.             case OPaltoMenos:
  615.                 *factory = (*factory>0)?*factory-1:0;
  616.                 sprintf(y,"%3d",*factory);
  617.                 MENSAJEponer(465,252,30,y);
  618.             break;
  619.                 /* otro, seguir */
  620.             default:
  621.             break;
  622.             }
  623.         break;
  624.         /* si derecho, salir */
  625.     case RATON_DCHO_ON:
  626.         op = NOOPC;
  627.     break;
  628.  
  629.         /* otro, seguir */
  630.     default:
  631.     break;
  632.     };
  633. }
  634. while(op!= NOOPC && op!= OPEscalado);
  635.  
  636. MENUquitar(5);
  637. return(op);
  638. }
  639.  
  640. /*---- FIN FUNCION -----------------------------------------------------------*/
  641.  
  642. /*---- FUNCION: extern int MENUInformar(IMAGEN *c) -----------------------------
  643.  
  644.     Descripción:
  645.  
  646.         Esta función muestra los datos de una imagen
  647.  
  648.     Parámetros:
  649.  
  650.         IMAGEN *c: puntero ala imagen
  651.  
  652.     Retorno:
  653.  
  654.         - NOOPC
  655.  
  656. ---- CODIGO: -----------------------------------------------------------------*/
  657.  
  658. extern int MENUInformar(IMAGEN *c)
  659. {
  660. char texto[100];
  661.  
  662.     /* si no hay imagen, error */
  663. if(c==NULL)
  664.     {
  665.     ERRORponer(ERRnoImagen);
  666.     ERRORver();
  667.     return(NOOPC);
  668.     }
  669.  
  670.     /* dar informe */
  671. RATONoculto();
  672. TECLAponer(&m[3]);
  673. TEXTOponer(270, 50,"Imagen");
  674. rectangle(270, 80,620,155);
  675. sprintf(texto,"Nombre: %s",c->nombre);
  676. TEXTOponer(280,90,texto);
  677. sprintf(texto,"Formato: %s",tabla_formatos[c->formato]+1);
  678. TEXTOponer(280,100,texto);
  679. switch(c->modo)
  680.     {
  681.     case VIDEOmono:sprintf(texto,"Modo de Video: Monocromo");break;
  682.     case VIDEOega:sprintf(texto,"Modo de Video: EGA");break;
  683.     case VIDEOvga:sprintf(texto,"Modo de Video: VGA");break;
  684.     };
  685. TEXTOponer(280,110,texto);
  686. sprintf(texto,"Dimensiones: %4d x %4d",c->ancho,c->alto);
  687. TEXTOponer(280,120,texto);
  688. sprintf(texto,"Colores: %4d",c->colores);
  689. TEXTOponer(280,130,texto);
  690. if(c->haypaleta)
  691.     sprintf(texto,"Paleta propia: SI");
  692. else
  693.     sprintf(texto,"Paleta propia: NO");
  694. TEXTOponer(280,140,texto);
  695.  
  696.     /* leer evento y salir */
  697. RATONvisible();
  698. leer_evento(evento);
  699. RATONoculto();
  700. MENUquitar(3);
  701. return(NOOPC);
  702. }
  703.  
  704. /*---- FIN FUNCION -----------------------------------------------------------*/
  705.  
  706. /*---- FUNCION: extern int MENUcoloresPoner(int *colores) ----------------------
  707.  
  708.     Descripción:
  709.  
  710.         Esta función muestra el menu de escalado de colores
  711.  
  712.     Parámetros:
  713.  
  714.         int *colores: número de colores
  715.  
  716.     Retorno:
  717.  
  718.         - OPColores para escalar colores
  719.         - NOOPC
  720.  
  721. ---- CODIGO: -----------------------------------------------------------------*/
  722.  
  723. extern int MENUcoloresPoner(int *colores)
  724. {
  725. char x[4];
  726. int op;
  727.  
  728.     /* poner menu */
  729. RATONoculto();
  730. TECLAponer(&m[5]);
  731. TEXTOponer(270,230,"Numero de colores a escalar");
  732. TECLAponer(&t[OPanchoMas]);
  733. TECLAponer(&t[OPanchoMenos]);
  734. TECLAponer(&t[OPEscalado]);
  735. sprintf(x,"%3d",*colores);
  736. MENSAJEponer(375,252,30,x);
  737.  
  738.     /* leer opcion */
  739. do
  740. {
  741. RATONvisible();
  742. evento = leer_evento(evento);
  743. RATONoculto();
  744.  
  745. switch(evento.e)
  746.     {
  747.     case RATON_IZDO_ON:
  748.         op = TestTecla(evento.x,evento.y);
  749.         switch(op)
  750.             {
  751.                 /* escalar colores */
  752.             case OPEscalado:
  753.                 op = OPColores;
  754.             break;
  755.                 /* mas colores */
  756.             case OPanchoMas:
  757.                 *colores = (*colores<256)?*colores*2:256;
  758.                 sprintf(x,"%3d",*colores);
  759.                 MENSAJEponer(375,252,30,x);
  760.             break;
  761.                 /* menos colores */
  762.             case OPanchoMenos:
  763.                 *colores = (*colores>2)?*colores/2:2;
  764.                 sprintf(x,"%3d",*colores);
  765.                 MENSAJEponer(375,252,30,x);
  766.             break;
  767.  
  768.                 /* otra, seguir */
  769.             default:
  770.             break;
  771.             }
  772.         break;
  773.  
  774.         /* si derecho o ESC, salir */
  775.     case ESC:
  776.     case RATON_DCHO_ON:
  777.         op = NOOPC;
  778.     break;
  779.  
  780.         /* si INTRO, escalar */
  781.     case RET: op = OPColores;
  782.     break;
  783.     default:
  784.     break;
  785.     };
  786. }
  787. while(op!= NOOPC && op!= OPColores);
  788.  
  789. MENUquitar(5);
  790. return(op);
  791. }
  792.  
  793. /*---- FIN FUNCION -----------------------------------------------------------*/
  794.  
  795. /*---- FUNCION: extern void MENUficheroDOS(char *fichero,int opc) --------------
  796.  
  797.     Descripción:
  798.  
  799.         Esta función muestra el menu de operaciones con ficheros DOS y las realiza
  800.  
  801.         Las operaciones son Borrar y Renombrar ficheros.
  802.  
  803.     Parámetros:
  804.  
  805.         char *fichero: fichero de entrada
  806.         int opc: opción a realizar sobre el fichero
  807.  
  808. ---- CODIGO: -----------------------------------------------------------------*/
  809.  
  810. extern void MENUficheroDOS(char *fichero,int opc)
  811. {
  812. char nombre[128];
  813. char mensaje[128];
  814. strcpy(nombre,fichero);
  815. switch(opc)
  816.     {
  817.     case OPBorrar:
  818.         if(MENUconfirmar("BORRAR FICHERO","Borrar",nombre))
  819.             {
  820.             sprintf(mensaje,"Borrando %s ",nombre);
  821.             ESTADOponer(mensaje);
  822.             if(remove(nombre))
  823.                 {
  824.                 ERRORponer(ERRnoBorrar);
  825.                 ERRORver();
  826.                 }
  827.             ESTADOquitar();
  828.             }
  829.     break;
  830.     case OPRenombrar:
  831.         sprintf(mensaje,"Renombrar %s",nombre);
  832.         if(MENUconfirmar("RENOMBRAR FICHERO",mensaje,nombre))
  833.             {
  834.             sprintf(mensaje,"Renombrando fichero %s a %s",mensaje,nombre);
  835.             ESTADOponer(mensaje);
  836.             if(rename(fichero,nombre))
  837.                 {
  838.                 ERRORponer(ERRnoRenombrar);
  839.                 ERRORver();
  840.                 }
  841.             ESTADOquitar();
  842.             }
  843.     break;
  844.     }
  845. strcpy(fichero,nombre);
  846. DirectorioLeer(fichero);
  847. }
  848.  
  849. /*---- FUNCION: extern int MENUconfirmar(char *msg1,char *msg2,char *cadena) ---
  850.  
  851.     Descripción:
  852.  
  853.         Esta función obtiene como respuesta una confirmación o cancelación
  854.         Puede opcioalmente leer una cadena de caracteres que se usa para
  855.         salvar,    borrar y renombrar ficheros.
  856.  
  857.     Parámetros:
  858.  
  859.         char *msg1: Texto principal
  860.         char *msg2: texto secundario
  861.         char *cadena: cadena usada como fichero
  862.  
  863.     Retorno:
  864.  
  865.         - 1 para confirmar
  866.         - 0 para cancelar
  867.  
  868. ---- CODIGO: -----------------------------------------------------------------*/
  869.  
  870. extern int MENUconfirmar(char *msg1,char *msg2, char *cadena)
  871. {
  872. int op = NOOPC;
  873.  
  874.     /* poner menu */
  875. RATONoculto();
  876. TECLAponer(&m[7]);
  877. TEXTOponer(270,320,msg1);
  878. if(strcmp(msg2,""))
  879.     TEXTOponer(270,340,msg2);
  880. if(strcmp(cadena,""))
  881.     MENSAJEponer(270,360,160,cadena);
  882.  
  883. TECLAponer(&t[OPCancelar]);
  884. TECLAponer(&t[OPAceptar]);
  885.  
  886. do
  887.     {
  888.     /* leer opcion */
  889. RATONvisible();
  890. evento = leer_evento(evento);
  891. RATONoculto();
  892.  
  893. switch(evento.e)
  894.     {
  895.     case RATON_IZDO_ON:
  896.         op = TestTecla(evento.x,evento.y);
  897.         switch(op)
  898.             {
  899.                 /* tecla cancelar o aceptar */
  900.             case OPCancelar:TECLAresaltar(&t[OPCancelar]);break;
  901.             case OPAceptar: TECLAresaltar(&t[OPAceptar]);break;
  902.       case OPficheroDOS:
  903.                 strcpy(cadena,LeerCadena(270,360,160,cadena));
  904.                 DirectorioLeer(cadena);
  905.             break;
  906.             default:
  907.             op = NOOPC;
  908.             break;
  909.             }
  910.     break;
  911.  
  912.         /* si INTRO, aceptar */
  913.     case RET:op = OPAceptar;break;
  914.  
  915.         /* si ESC, cancelar */
  916.     case ESC:op=OPCancelar;break;
  917.     default:op =NOOPC;break;
  918.     }
  919.     }
  920. while(op!=OPCancelar && op!=OPAceptar);
  921. MENUquitar(7);
  922. return(op-OPCancelar);
  923. }
  924.  
  925. /*---- CODIFICACION DE LAS FUNCIONES INTERNAS --------------------------------*/
  926.  
  927. /*---- FUNCION: struct lista *DirectorioInsLista(struct lista *l,char *f) ------
  928.  
  929.     Descripción:
  930.  
  931.         Esta función inserta un fichero o directorio en la lista
  932.  
  933.     Parámetros:
  934.  
  935.         struct lista *l: puntero a la lista
  936.         char *f: fichero
  937.  
  938.     Retorno:
  939.  
  940.         Puntero a la lista
  941.  
  942. ---- CODIGO: -----------------------------------------------------------------*/
  943.  
  944. struct lista *DirectorioInsLista(struct lista *l,char *f)
  945. {
  946. struct lista *p,*q;
  947.     /* reserva memoria para el elemento */
  948. if((p = (struct lista *)malloc(sizeof(struct lista)))== NULL)
  949.     {
  950.     ERRORponer(ERRnoMemoria);
  951.     ERRORver();
  952.     return(l);
  953.     }
  954.     /* rellena el nuevo elemento */
  955. strcpy(p->f,f);
  956. p->e = OFF;
  957. p->s = p->a = NULL;
  958.  
  959.     /* añade al final */
  960. if(l!=NULL)
  961.     {
  962.     q = l;
  963.     while(q->s!=NULL)
  964.         q=q->s;
  965.     q->s = p;
  966.     p->a = q;
  967.     }
  968. else
  969.     l=p;
  970. return(l);
  971. }
  972.  
  973. /*---- FIN FUNCION -----------------------------------------------------------*/
  974.  
  975. /*---- FUNCION: struct lista *DirectorioLiberarLista(struct lista *l) ----------
  976.  
  977.     Descripción:
  978.  
  979.         Esta función destruye la lista de ficheros
  980.  
  981.     Parámetros:
  982.  
  983.         struct lista *l: puntero a la lista
  984.  
  985.     Retorno:
  986.  
  987.         Puntero a la lista
  988.  
  989. ---- CODIGO: -----------------------------------------------------------------*/
  990.  
  991.  
  992. struct lista *DirectorioLiberarLista(struct lista *l)
  993. {
  994. struct lista *p;
  995. p = l;
  996.     /* liberar todos los elementos */
  997. while(l != NULL)
  998.     {
  999.     p = l->s;
  1000.     free(l);
  1001.     l= p;
  1002.     }
  1003. return(l);
  1004. }
  1005.  
  1006. /*---- FIN FUNCION -----------------------------------------------------------*/
  1007.  
  1008. /*---- FUNCION: void DirectorioVerLista(struct lista *l) -----------------------
  1009.  
  1010.     Descripción:
  1011.  
  1012.         Esta función muestra la lista de ficheros y directorios
  1013.  
  1014.     Parámetros:
  1015.  
  1016.         struct lista *l: puntero a la lista
  1017.  
  1018. ---- CODIGO: -----------------------------------------------------------------*/
  1019.  
  1020. void DirectorioVerLista(struct lista *l)
  1021. {
  1022. int i;
  1023. struct lista *p;
  1024. setfillstyle(SOLID_FILL,c3);
  1025. bar(16,96,124,353);
  1026. setcolor(c2);
  1027. for(i =0,p = l;p!=NULL && i<21;p=p->s,i++)
  1028.         /* si esta seleccionado */
  1029.     if(p->e)
  1030.         TEXTOresaltar(16,100+i*12,108,p->f);
  1031.         /* si no */
  1032.     else
  1033.         TEXTOponer(16,100+i*12,p->f);
  1034. }
  1035.  
  1036. /*---- FIN FUNCION -----------------------------------------------------------*/
  1037.  
  1038. /*---- FUNCION: void DirectorioLeer(char *direc) -------------------------------
  1039.  
  1040.     Descripción:
  1041.  
  1042.         Esta función lee del disco y carga la nueva lista de directorios y
  1043.         ficheros
  1044.  
  1045.     Parámetros:
  1046.  
  1047.         char *direc: puntero al path a leer
  1048.  
  1049. ---- CODIGO: -----------------------------------------------------------------*/
  1050.  
  1051. void DirectorioLeer(char *direc)
  1052. {
  1053. int disco;
  1054. char temp[MAXPATH];
  1055.  
  1056. strupr(direc);
  1057. strcpy(temp,direc);
  1058.  
  1059.     /* mostrar en el recuadro de fichero, fichero(s) actual(es) */
  1060. MENSAJEponer(18,62,224,direc);
  1061.  
  1062.     /* si la lista no esta vacia, liberarla */
  1063. if(l != NULL)
  1064.     l = DirectorioLiberarLista(l);
  1065.  
  1066.     /* desglosar el path */
  1067. fnsplit(direc,drive,dir,file,ext);
  1068. fnmerge(temp,drive,dir,"*",".");
  1069.  
  1070.     /* unidad de disco */
  1071. disco = drive[0]-'A';
  1072.     /* si no existe disco B: */
  1073. if(disco == 1)
  1074.     if(!(biosequip() & 0x40))
  1075.         return;
  1076.  
  1077.     /* cargar los subdirectorios del nuevo directorio */
  1078. if(!findfirst(temp,&ff,FA_DIREC))
  1079.     {
  1080.     if(ff.ff_attrib== FA_DIREC)
  1081.         {
  1082.         l = DirectorioInsLista(l,ff.ff_name);
  1083.         while(!findnext(&ff) && ff.ff_attrib == FA_DIREC)
  1084.             l = DirectorioInsLista(l,ff.ff_name);
  1085.         }
  1086.     }
  1087.     /* cargar los ficheros del nuevo directorio */
  1088. if(!findfirst(direc,&ff,FA_ARCH))
  1089.     {
  1090.     l = DirectorioInsLista(l,ff.ff_name);
  1091.     while(!findnext(&ff))
  1092.         l = DirectorioInsLista(l,ff.ff_name);
  1093.     }
  1094. actual = l;
  1095.     /* ver la lista */
  1096. DirectorioVerLista(actual);
  1097. }
  1098.  
  1099. /*---- FIN FUNCION -----------------------------------------------------------*/
  1100.  
  1101. /*---- FUNCION: void DirectorioTratarLista(int y) ------------------------------
  1102.  
  1103.     Descripción:
  1104.  
  1105.         Esta función identifica y trata un elemento de la lista de ficheros y
  1106.         directorios
  1107.  
  1108.     Parámetros:
  1109.  
  1110.         int y: coordenada y del lugar señalado con el ratón
  1111.  
  1112. ---- CODIGO: -----------------------------------------------------------------*/
  1113.  
  1114. void DirectorioTratarLista(int y)
  1115. {
  1116. int i,inc;
  1117. struct lista *p,*q=NULL;
  1118. char drive2[MAXDRIVE];
  1119. char dir2[MAXDIR];
  1120. char file2[MAXFILE];
  1121. char ext2[MAXEXT];
  1122.  
  1123. fnsplit(accion.fichero,drive,dir,file,ext);
  1124. fnsplit(accion.fichero,drive,dir,file2,ext2);
  1125.  
  1126.     /* identifica el elemento en la lista */
  1127. inc = (y-99)/12;
  1128. p = actual;
  1129. if(p !=NULL)
  1130.     for(i=0;(i<inc) && (p->s != NULL);i++)
  1131.         p = p->s;
  1132.  
  1133. if(p!=NULL && (i==inc))
  1134.     {
  1135.         /* si no estaba seleccionado, seleccionar */
  1136.     if(!p->e)
  1137.         {
  1138.         for(q = l;q!=NULL;q=q->s)
  1139.             q->e = OFF;
  1140.         p->e = ON;
  1141.         DirectorioVerLista(actual);
  1142.         }
  1143.         /* si lo estaba, actuar */
  1144.     else
  1145.         {
  1146.         fnsplit(p->f,drive2,dir2,file2,ext2);
  1147.             /* si es el directorio raiz, ir a la raiz */
  1148.         if(!strcmp(dir2,"."))
  1149.             {
  1150.             fnsplit(accion.fichero,drive,dir,file,ext);
  1151.             fnmerge(accion.fichero,drive,"\\","*",ext);
  1152.             }
  1153.         else
  1154.                 /* si es el directorio anterior, ir al anterior */
  1155.             if(!strcmp(dir2,".."))
  1156.                 {
  1157.                 fnsplit(accion.fichero,drive,dir,file,ext);
  1158.                 for(i = strlen(dir)-2;dir[i]!='\\';i--);
  1159.                 dir[i+1]=0;
  1160.                 fnmerge(accion.fichero,drive,dir,"*",ext);
  1161.                 }
  1162.             else
  1163.                 {
  1164.                 fnmerge(accion.fichero,drive,dir,file2,ext2);
  1165.                     /* si es un directorio, añadirlo al camino */
  1166.                 if(findfirst(accion.fichero,&ff,FA_ARCH))
  1167.                     {
  1168.                     strcat(dir,p->f);
  1169.                     fnmerge(accion.fichero,drive,dir,"*",ext);
  1170.                     }
  1171.                 }
  1172.             /* leer nuevo directorio */
  1173.         DirectorioLeer(accion.fichero);
  1174.         }
  1175.     }
  1176. }
  1177.  
  1178. /*---- FIN FUNCION -----------------------------------------------------------*/
  1179.  
  1180. /*---- FUNCION: int TipoFichero(char *fichero) ---------------------------------
  1181.  
  1182.     Descripción:
  1183.  
  1184.         Esta función devuelve el tipo de fichero identificándolo por
  1185.         su extensión
  1186.  
  1187.     Parámetros:
  1188.  
  1189.         char *fichero: nombre del fichero
  1190.  
  1191.     Retorno:
  1192.  
  1193.         Tipo de fichero
  1194.  
  1195. ---- CODIGO: -----------------------------------------------------------------*/
  1196.  
  1197.  
  1198. int TipoFichero(char *fichero)
  1199. {
  1200. int i;
  1201. char unidad[MAXDRIVE];
  1202. char directorio[MAXDIR];
  1203. char archivo[MAXFILE];
  1204. char extension[MAXEXT];
  1205.  
  1206.     /* extraer la extension */
  1207. fnsplit(fichero,unidad,directorio,archivo,extension);
  1208. strupr(extension);
  1209.     /* comparar extension y devolver tipo */
  1210. for(i=0;i<NUM_FORMATOS;++i)
  1211.     {
  1212.     if(!memcmp(extension,tabla_formatos[i],3))
  1213.         {
  1214.         accion.tipo = i;
  1215.         return(i);
  1216.         }
  1217.     }
  1218. return(OTRO);
  1219. }
  1220.  
  1221. /*---- FIN FUNCION -----------------------------------------------------------*/
  1222.  
  1223. /*---- FUNCION: void MENUquitar(int i) -----------------------------------------
  1224.  
  1225.     Descripción:
  1226.  
  1227.         Esta función oculta un menu
  1228.  
  1229.     Parámetros:
  1230.  
  1231.         int i: número del recuadro  o marco del menu
  1232.  
  1233. ---- CODIGO: -----------------------------------------------------------------*/
  1234.  
  1235. void MENUquitar(int i)
  1236. {
  1237. setfillstyle(SOLID_FILL,c3);
  1238. bar(m[i].x,m[i].y,m[i].x+m[i].ancho,m[i].y+m[i].alto);
  1239. RATONvisible();
  1240. }
  1241.  
  1242. /*---- FIN FUNCION -----------------------------------------------------------*/
  1243.